package entry;

import java.nio.charset.Charset;
import java.util.Collections;
import java.util.Comparator;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.EnumerablePropertySource;
import org.springframework.core.env.Environment;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.stereotype.Component;

@Component
public class Env {
	@Autowired
	ApplicationContext ac;
	
	@Autowired
    ConfigurableEnvironment springEnv;
	
	@PostConstruct
	public void after() {
		Environment environment = ac.getEnvironment();
		System.out.println( "aaa->"+environment.getClass() );
		System.out.println( "bbb->"+springEnv.getClass() );
		
		 MutablePropertySources propSrcs = springEnv.getPropertySources();
	        //  // 获取所有配置 key -> [source, key, value]
//		 propSrcs.stream().filter((ps) -> { return ps instanceof EnumerablePropertySource;});
/*	        Map<String, String[]> props = propSrcs.stream()
	                .filter( (ps) -> { return ps instanceof EnumerablePropertySource;} )
	                .map(ps -> (EnumerablePropertySource<?>) ps)
	                .flatMap(ps -> {
	                            String psName = ps.getName();
	                            if (psName.startsWith("applicationConfig")) {
	                                psName = psName.substring(31);
	                                psName = psName.substring(0, psName.length() - 1);
	                            }
	                            final String fpsName = psName;
	                            return Arrays.stream(ps.getPropertyNames())
	                                    .map(ppName -> new String[]{fpsName, ppName, springEnv.getProperty(ppName)});
	                        }
	                )
	                .distinct()
	                .sorted(Comparator.comparing(pArr -> pArr[1]))
	                .collect(Collectors.toMap(pArr -> pArr[1], Function.identity(), (pArr1, pArr2) -> pArr1));

	        // key 和 value 之间的最小间隙
	        int interval = 20;
	        int max01 = props.values().stream()
	                .map(pArr -> pArr[0])
	                .max(Comparator.comparingInt(String::length))
	                .orElse("")
	                .length();
	        int max12 = props.values().stream()
	                .map(pArr -> pArr[1])
	                .max(Comparator.comparingInt(String::length))
	                .orElse("")
	                .length();

	        // 打印
	        String propStr = props.entrySet().stream()
	                .sorted(Map.Entry.comparingByKey())
	                .map(e -> {
	                    String[] pArr = e.getValue();
	                    int i01 = max01 - pArr[0].length() + interval;
	                    int i12 = max12 - pArr[1].length() + interval;
	                    String p01 = String.join("", Collections.nCopies(i01, " "));
	                    String p12 = String.join("", Collections.nCopies(i12, " "));
	                    return pArr[0] + p01 + pArr[1] + p12 + pArr[2];
	                })
	                .reduce((s1, s2) -> s1 + "\n" + s2)
	                .orElse("");
	        System.out.println("开始输出环境变量");
	        System.out.println("\n" + propStr);
	        System.out.println("环境变量输出完毕");
*/	        
//		environment.
	}
	
	public static void main(String[] args) {
		System.out.println( Charset.forName("UTF-8") );
		System.out.println( Charset.forName("GBK") );
		System.out.println( Charset.forName("ISO8859-1") );
		System.out.println( Charset.forName("ZHS16GBK") );
	}
}
